// import store from '@/store';
// websocket实例
let wsObj = null;
// ws连接地址
let wsUrl = null;
// let userId = null;
// 是否执行重连 true/不执行 ； false/执行
let lockReconnect = false;
// 重连定时器
let wsCreateHandler = null;
// 连接成功，执行回调函数
let messageCallback = null;
// 连接失败，执行回调函数
let errorCallback = null;
// 发送给后台的数据
let sendDatas = {};

// 20秒一次心跳
let timeout = 30 * 1000;
// 心跳心跳倒计时
let timeoutObj = null;
// 心跳倒计时
let serverTimeoutObj = null;
// 播放的二进制数据
let broadcastList = []
let broadcastIndex = 0

/**
 * 发起websocket请求函数
 * @param {string} url ws连接地址
 * @param {Object} agentData 传给后台的参数
 * @param {function} successCallback 接收到ws数据，对数据进行处理的回调函数
 * @param {function} errCallback ws连接错误的回调函数
 */
export const connectWebsocket = (url, successCallback, errCallback, agentData) => {
	lockReconnect = false;
	wsUrl = url;
	createWebSoket();
	messageCallback = successCallback;
	errorCallback = errCallback;
	sendDatas = agentData;
}
// 发送消息
export const sendWebsocket = (data) => {
	// 注：只有连接正常打开中 ，才能正常成功发送消息
	if (wsObj) {
		const msg = JSON.stringify({
			code: 200,
			data,
			msg: 'success'
		})
		wsObj.send({
			data: msg,
			success() {
				// writeToScreen("消息发送成功");
			},
		});
	}
}
// 手动关闭websocket （这里手动关闭会执行onclose事件）
export const closeWebsocket = () => {
	if (wsObj) {
		writeToScreen('手动关闭websocket');
		wsObj.close() // 关闭websocket
		// wsObj.onclose() // 关闭websocket(如果上面的关闭不生效就加上这一条)
		// 关闭重连
		lockReconnect = true;
		wsCreateHandler && clearTimeout(wsCreateHandler);
	}
}

// 创建ws函数
const createWebSoket = () => {
	try {
		wsObj = uni.connectSocket({
			url: wsUrl,
			success: () => {
				// writeToScreen("正准备建立websocket中...");
				return wsObj
			},
		});
		initWsEventHandle();
	} catch (e) {
		// uni.$u.toast('连接异常,开始重连');
		reconnect();
	}
}

const initWsEventHandle = () => {
	try {
		// 连接成功
		wsObj.onOpen((event) => {
			onWsOpen(event);
			// 开启心跳
			heartCheckWebSocket();
		})

		// 监听服务器端返回的信息
		wsObj.onMessage((eventMsg) => {
			onWsMessage(eventMsg);
		})

		wsObj.onClose((event) => {
			writeToScreen('onclose执行关闭事件');
			onWsClose(event);
		})

		wsObj.onError((event) => {
			// uni.$u.toast('onerror执行error事件,开始重连');
			onWsError(event);
			reconnect();
		})
	} catch (err) {
		// uni.$u.toast('绑定事件没有成功,开始重连');
		reconnect();
	}
}
// 开启心跳
const heartCheckWebSocket = () => {
	timeoutObj && clearTimeout(timeoutObj);
	serverTimeoutObj && clearTimeout(serverTimeoutObj);
	timeoutObj = setTimeout(function() {
		// 这里发送一个心跳，后端收到后，返回一个心跳消息
		if (wsObj.readyState == 1) {
			// 如果连接正常
			const data = {
				uid:uni.getStorageSync('userData')?.uid
			}
			sendWebsocket(data);
		} else {
			// 否则重连
			reconnect();
		}
		serverTimeoutObj = setTimeout(function() {
			// 超时关闭
			writeToScreen('连接超时----------- ');
			wsObj.close();
		}, timeout);
	}, timeout);
}
// 重置心跳
const heartCheckWebSocketReset = () => {
	// 清除时间
	clearTimeout(timeoutObj);
	clearTimeout(serverTimeoutObj);
	// 重置心跳
	heartCheckWebSocket();
}

const onWsOpen = (event) => {
	writeToScreen('CONNECT'); // 连接
	// // 客户端与服务器端通信
	// wsObj.send('我发送消息给服务端');
	// 添加状态判断，当为OPEN时，发送消息
	if (wsObj.readyState === wsObj.OPEN) { // wsObj.OPEN = 1
		// 发给后端的数据需要字符串化
		if (sendDatas) sendWebsocket(sendDatas);
	}
	if (wsObj.readyState === wsObj.CLOSED) { // wsObj.CLOSED = 3
		writeToScreen('wsObj.readyState=3, ws连接异常,开始重连');
		reconnect();
		errorCallback();
	}
}
const onWsMessage = (event) => {
	if (!uni.getStorageSync('lifeData').hasLogin) { //退出登录-关闭Socket
		closeWebsocket()
		return
	}
	// 收到服务数据信息，重置心跳
	heartCheckWebSocketReset()
	if (typeof event.data === 'string') {
		try{
			const jsonStr = JSON.parse(event.data);
			messageCallback(jsonStr);
		}catch(e){
			// console.log(e,'eeee');
			//TODO handle the exception
		}
	} else {
		// const target = `${wx.env.USER_DATA_PATH}/${new Date().getTime()}.mp3`
		try {
			// const res = fs.writeFileSync(
			// 	target,
			// 	event.data,
			// 	'binary'
			// )
			// // 将接收到的消息推进消息队列
			// broadcastList.push(target);
			// // console.log(broadcastList, broadcastIndex, '将接收到的消息推进消息队列')
			// if (!store.state.isBroadcasting) {
			// 	wxAudioContext.src = target
			// 	wxAudioContext.play()
			// }
		} catch (e) {}
	}
}
const onWsClose = (event) => {
	writeToScreen('DISCONNECT'); // 断开连接
	// e.code === 1000  表示正常关闭。 无论为何目的而创建, 该链接都已成功完成任务。
	// e.code !== 1000  表示非正常关闭。
	if (event && event.code !== 1000) {
		writeToScreen('非正常关闭');
		errorCallback();
		// 如果不是手动关闭，这里的重连会执行；如果调用了手动关闭函数，这里重连不会执行
		reconnect();
	}
}
const onWsError = (event) => {
	writeToScreen('onWsError: ', event.data);
	errorCallback();
}

const writeToScreen = (massage) => {
	console.log(massage);
}
// 重连函数
const reconnect = () => {
	if (lockReconnect) {
		return;
	}
	writeToScreen('3秒后重连');
	lockReconnect = true;
	// 没连接上会一直重连，设置延迟避免请求过多
	wsCreateHandler && clearTimeout(wsCreateHandler);
	wsCreateHandler = setTimeout(() => {
		writeToScreen('重连...' + wsUrl);
		createWebSoket();
		lockReconnect = false;
		writeToScreen('重连完成');
	}, 3000);
}
// //监听开始播放
// wxAudioContext.onPlay(() => {
// 	store.state.isBroadcasting = true
// })
// //监听播报结束
// wxAudioContext.onEnded(() => {
// 	try {
// 		const unpath = broadcastList[broadcastIndex]
// 		fs.unlinkSync(unpath) //删除本地文件
// 		store.state.isBroadcasting = false
// 		broadcastIndex++
// 		// console.log(broadcastIndex, broadcastList.length, broadcastIndex < broadcastList.length,
// 		// 	'播报结束')
// 		if (broadcastIndex < broadcastList.length) {
// 			wxAudioContext.src = broadcastList[broadcastIndex]
// 			wxAudioContext.play()
// 		} else {
// 			broadcastIndex = 0
// 			broadcastList = []
// 		}
// 	} catch (e) {}
// 	// console.log(broadcastList, '播放结束')
// })
